home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / tcqb.arc / TCIO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-01-28  |  3.0 KB  |  216 lines
  1. #pragma inline
  2.  
  3. int open(char *fname)
  4. {
  5.     asm mov dx,fname
  6.     asm mov al,0
  7.     asm mov ah,3dh
  8.     asm int 21h
  9.     asm jc err
  10.     return _AX;
  11. err:    return 0;
  12. }
  13.  
  14. int create(char *fname)
  15. {
  16.     asm mov dx,fname
  17.     asm mov cx,0
  18.     asm mov ah,3ch
  19.     asm int 21h
  20.     asm jc err
  21.     return _AX;
  22. err:    return 0;
  23. }
  24.  
  25. #define MAXTRAN    (32768)        /* maximum bytes transfered with 1 dos call */
  26.  
  27. unsigned int zread(int fs,unsigned char *buf,unsigned int cnt)
  28. {
  29.     asm mov ax,ds
  30.     asm mov es,ax
  31.     asm mov bx,fs
  32.     asm mov dx,buf
  33.     asm mov cx,cnt
  34.     asm mov ah,3fh
  35.     asm int 21h
  36.     return _AX;
  37. }
  38.  
  39. long read(int fs,long lcount,unsigned char *buf)
  40. {
  41.     long total;
  42.     unsigned int bcnt;
  43.  
  44.     total=0;
  45.     while(lcount>MAXTRAN)
  46.     {
  47.         bcnt=zread(fs,buf,MAXTRAN);
  48.         total+=bcnt;
  49.         if(bcnt!=MAXTRAN)
  50.             return total;
  51.     }
  52.     bcnt=zread(fs,buf,(unsigned int)lcount);
  53.     return total+bcnt;
  54. }
  55.  
  56. unsigned int zwrite(int fs,unsigned char *buf,unsigned int cnt)
  57. {
  58.     asm mov ax,ds
  59.     asm mov es,ax
  60.     asm mov bx,fs
  61.     asm mov dx,buf
  62.     asm mov cx,cnt
  63.     asm mov ah,40h
  64.     asm int 21h
  65.     return _AX;
  66. }
  67.  
  68. long write(int fs,long lcount,unsigned char *buf)
  69. {
  70.     long total;
  71.     unsigned int bcnt;
  72.  
  73.     total=0;
  74.     while(lcount>MAXTRAN)
  75.     {
  76.         bcnt=zwrite(fs,buf,MAXTRAN);
  77.         total+=bcnt;
  78.         if(bcnt!=MAXTRAN)
  79.             return total;
  80.     }
  81.     bcnt=zwrite(fs,buf,(unsigned int)lcount);
  82.     return total+bcnt;
  83. }
  84.  
  85. #pragma warn -rvl
  86.  
  87. long lseek(int fs,long pos,int mode)
  88. {
  89.     asm mov bx,fs
  90.     asm mov dx,pos
  91.     asm mov cx,pos+2
  92.     asm mov al,mode
  93.     asm mov ah,42h
  94.     asm int 21h
  95. }
  96.  
  97. void close(int fs)
  98. {
  99.     asm mov bx,fs
  100.     asm mov ah,3eh
  101.     asm int 21h
  102. }
  103.  
  104. putchar(chr)
  105. unsigned char chr;
  106. {
  107.     asm mov bx,1
  108.     asm mov cx,1
  109.     asm lea dx,chr
  110.     asm mov ah,40h
  111.     asm int 21h
  112. }
  113.  
  114. sput(str)
  115. char *str;
  116. {
  117.     asm mov ax,ds
  118.     asm mov es,ax
  119.     asm mov dx,str
  120.     asm mov di,dx
  121.     asm mov al,0
  122.     asm mov cx,-1
  123.     asm cld 
  124.     asm repnz scasb
  125.     asm not cx
  126.     asm dec cx
  127.     asm mov bx,1
  128.     asm mov ah,40h
  129.     asm int 21h
  130. }
  131.  
  132. static unsigned char flg,chr;
  133.  
  134. int chkkbd()
  135. {
  136.     asm mov al,flg 
  137.     asm or al,al
  138.     asm jnz alredy  
  139.     asm mov ah,1
  140.     asm int 16h
  141.     asm sti
  142.     asm jz nochr  
  143.     asm mov ah,0
  144.     asm int 16h
  145.     asm or al,al
  146.     asm jnz okch
  147.     asm inc flg
  148.     asm mov al,ah
  149. okch:    asm mov chr,al 
  150.     asm inc flg  
  151. alredy:    return 1;
  152. nochr:    return 0;
  153. }
  154.  
  155. int getkey()
  156. {
  157. kbdlp:    asm call chkkbd  
  158.     asm or ax,ax
  159.     asm jz kbdlp  
  160.     asm mov al,0
  161.     asm dec flg
  162.     asm jnz func
  163.     asm mov al,chr 
  164. func:    return _AX;
  165. }
  166.  
  167. int fgetkey()
  168. {
  169.     int c;
  170.  
  171.     if(!(c=getkey()))
  172.         c=getkey()|256;
  173.     return c;
  174. }
  175.  
  176. void putint(num,nlen)
  177. register unsigned int num;
  178. int nlen;
  179. {
  180. register char *pnt;
  181.     char buf[6];
  182.  
  183.     pnt=buf+sizeof(buf);
  184.     *--pnt=0;
  185.     do
  186.     {
  187.         *--pnt=num%10+'0';    /* next digit */
  188.         num/=10;
  189.         --nlen;
  190.     } while(num);
  191.     while(nlen--)
  192.         *--pnt=' ';
  193.     sput(pnt);
  194. }
  195.  
  196. void putlint(num,nlen)
  197. unsigned long num;
  198. register int nlen;
  199. {
  200. register char *pnt;
  201.     char buf[11];
  202.  
  203.     pnt=buf+sizeof(buf);
  204.     *--pnt=0;
  205.     do
  206.     {
  207.         *--pnt=num%10+'0';    /* next digit */
  208.         num/=10;
  209.         --nlen;
  210.     } while(num);
  211.     while(nlen--)
  212.         *--pnt=' ';
  213.     sput(pnt);
  214. }
  215.  
  216.